package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.service.AlbumAttributeValueService;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.cache.TsCache;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

    @Autowired
    private AlbumInfoMapper albumInfoMapper;

    @Autowired
    private AlbumAttributeValueMapper albumAttributeValueMapper;

    @Autowired
    private AlbumStatMapper albumStatMapper;
    @Autowired
    AlbumAttributeValueService albumAttributeValueService;

    @Autowired
    private RabbitService rabbitService;


    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedissonClient redissonClient;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
        //创建专辑对象
        AlbumInfo albumInfo = new AlbumInfo();
        //属性拷贝
        BeanUtils.copyProperties(albumInfoVo, albumInfo);
        //设置专辑审核状态为：通过
        albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
        //设置用户ID
        albumInfo.setUserId(userId);
        //付费的默认前5集免费试看
        if (!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())) {
            albumInfo.setTracksForFree(5);
        }
        //保存专辑
        this.save(albumInfo);
        //保存专辑属性值
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
        //判断属性值是否为空
        if (!CollectionUtils.isEmpty(albumAttributeValueVoList)) {

			ArrayList<AlbumAttributeValue> albumAttributeValueList = new ArrayList<>();
			/*//循环比例设置字段值
			albumAttributeValueVoList.stream().forEach(albumAttributeValueVo ->{
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
				albumAttributeValue.setAlbumId(albumInfo.getId());
				//保存数据
				albumAttributeValueMapper.insert(albumAttributeValue);
			});*/

			//循环遍历设置字段值
			albumAttributeValueVoList.stream().forEach(albumAttributeValueVo ->{
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
				albumAttributeValue.setAlbumId(albumInfo.getId());
				//保存数据
				albumAttributeValueList.add(albumAttributeValue);
			});
			albumAttributeValueService.saveBatch(albumAttributeValueList);
		}
		saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_PLAY);
		saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_SUBSCRIBE);
		saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_BROWSE);
		saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_COMMENT);

		//  判断当前专辑是公开; is_open=1;
		if ("1".equals(albumInfo.getIsOpen())){
			//  调用上架方法;
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER, albumInfo.getId());
		}

	}

	@Override
	public IPage<AlbumListVo> findUserAlbumPage(Page<AlbumListVo> albumInfoPage, AlbumInfoQuery albumInfoQuery) {
		return albumInfoMapper.selectUserAlbumPage(albumInfoPage,albumInfoQuery);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void removeAlbumInfoById(Long id) {
		//删除专辑表的数据
		this.removeById(id);
		//删除专辑属性信息
		albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId,id));
		//删除专辑对应的统计数据
		albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>().eq(AlbumStat::getAlbumId,id));

		//下架
//		rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM, MqConst.ROUTING_ALBUM_LOWER, albumInfo.getId());
	}

	@Override
	public AlbumInfo getAlbumInfoById(Long id) {
		//根据id查询专辑数据
		AlbumInfo albumInfo = this.getById(id);
		//回显时，需要回显专辑数据信息数据
		if(albumInfo != null){
			List<AlbumAttributeValue> albumAttributeValueList =
					albumAttributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId,id));
			albumInfo.setAlbumAttributeValueVoList(albumAttributeValueList);
		}
		/*AlbumInfo albumInfo = albumInfoMapper.selectById(id);
		//为了防止空指针
		if(null != albumInfo){
			LambdaQueryWrapper<AlbumAttributeValue> wrapper = new LambdaQueryWrapper<>();
			wrapper.eq(AlbumAttributeValue::getAlbumId,id);
			List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(wrapper);
			albumInfo.setAlbumAttributeValueVoList(albumAttributeValueList);
		}*/
		return albumInfo;
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
		AlbumInfo albumInfo = this.getById(id);
		BeanUtils.copyProperties(albumInfoVo,albumInfo);
		//根据id修改数据
		this.updateById(albumInfo);
		//先删除专辑属性数据
		albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId,id));
		//保存专辑属性数据
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		if(!CollectionUtils.isEmpty(albumAttributeValueVoList)){
			albumAttributeValueVoList.forEach(albumAttributeValueVo ->{
				//创建专辑属性对象
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				//进行数据拷贝
				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
				//赋值专属属性id
				albumAttributeValue.setAlbumId(id);
				albumAttributeValueMapper.insert(albumAttributeValue);
			});
		}
		//更新上架下架
		if("1".equals(albumInfo.getIsOpen())){
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,albumInfo.getId());
		}else{
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,albumInfo.getId());
		}


	}

	@Override
	public List<AlbumInfo> findUserAlbumList(Long userId) {
		//默认查看第一页
		Page<AlbumInfo> albumInfoPage = new Page<>(1,100);
		//设置查询条件
		LambdaQueryWrapper<AlbumInfo> wrapper = new LambdaQueryWrapper<>();
		wrapper.select(AlbumInfo::getId,AlbumInfo::getAlbumTitle);
		wrapper.eq(AlbumInfo::getUserId,userId);
		wrapper.orderByAsc(AlbumInfo::getId);
		return albumInfoMapper.selectPage(albumInfoPage,wrapper).getRecords();
	}

	@Override
	public List<AlbumAttributeValue> findAlbumAttributeValueByAlbumId(Long albumId) {
		LambdaQueryWrapper<AlbumAttributeValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
		lambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId,albumId);
		List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(lambdaQueryWrapper);
		//返回集合数据
		return albumAttributeValueList;
	}

	@Override
	public AlbumStatVo getAlbumStatVo(Long albumId) {
		//调用Mapper方法
		return albumInfoMapper.selectAlbumStatVo(albumId);
	}

	private void saveAlbumStat(Long albumId,String statType){
		AlbumStat albumStat = new AlbumStat();
		albumStat.setAlbumId(albumId);
		albumStat.setStatType(statType);
		albumStat.setStatNum(0);
		albumStatMapper.insert(albumStat);
	}
}
